Jassif Team Institution

const { setTimeout, setInterval, setImmediate } = require('timers');

console.log('Starting timers...');

// Execute once after delay
setTimeout(() => {
  console.log('This runs after 1 second');
}, 1000);

// Execute repeatedly at interval
let counter = 0;
const interval = setInterval(() => {
  counter++;
  console.log(`Interval tick ${counter}`);
  if (counter >= 3) clearInterval(interval);
}, 1000);

// Execute in the next event loop iteration
setImmediate(() => {
  console.log('This runs in the next iteration of the event loop');
});

console.log('Timers scheduled');

const timers = require('timers');

// Or, for the promises API (Node.js 15.0.0+)
const timersPromises = require('timers/promises');

// Basic usage
setTimeout(() => {
  console.log('This message is displayed after 2 seconds');
}, 2000);

// With arguments
setTimeout((name) => {
  console.log(`Hello, ${name}!`);
}, 1000, 'World');

// Storing and clearing a timeout
const timeoutId = setTimeout(() => {
  console.log('This will never be displayed');
}, 5000);

// Cancel the timeout before it executes
clearTimeout(timeoutId);
console.log('Timeout has been cancelled');

const { setTimeout } = require('timers/promises');

async function delayedGreeting() {
  console.log('Starting...');

  // Wait for 2 seconds
  await setTimeout(2000);

  console.log('After 2 seconds');

  // Wait for 1 second with a value
  const result = await setTimeout(1000, 'Hello, World!');

  console.log('After 1 more second:', result);
}

delayedGreeting().catch(console.error);

// Basic interval
let counter = 0;
const intervalId = setInterval(() => {
  counter++;
  console.log(`Interval executed ${counter} times`);

  // Stop after 5 executions
  if (counter >= 5) {
    clearInterval(intervalId);
    console.log('Interval stopped');
  }
}, 1000);

// Interval with arguments
const nameInterval = setInterval((name) => {
  console.log(`Hello, ${name}!`);
}, 2000, 'Node.js');

// Stop the name interval after 6 seconds
setTimeout(() => {
  clearInterval(nameInterval);
  console.log('Name interval stopped');
}, 6000);

const { setInterval } = require('timers/promises');

async function repeatedGreeting() {
  console.log('Starting interval...');

  // Create an async iterator from setInterval
  const interval = setInterval(1000, 'tick');

  // Limit to 5 iterations
  let counter = 0;

  for await (const tick of interval) {
    console.log(counter + 1, tick);
    counter++;

    if (counter >= 5) {
      break; // Exit the loop, stopping the interval
    }
  }

  console.log('Interval finished');
}

repeatedGreeting().catch(console.error);

console.log('Start');

setTimeout(() => {
  console.log('setTimeout callback');
}, 0);

setImmediate(() => {
  console.log('setImmediate callback');
});

process.nextTick(() => {
  console.log('nextTick callback');
});

console.log('End');

const immediateId = setImmediate(() => {
  console.log('This will not be displayed');
});

clearImmediate(immediateId);
console.log('Immediate has been cancelled');

console.log('Start');

// Schedule three different types of callbacks
setTimeout(() => {
  console.log('setTimeout executed');
}, 0);

setImmediate(() => {
  console.log('setImmediate executed');
});

process.nextTick(() => {
  console.log('nextTick executed');
});

console.log('End');

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => func.apply(this, args), delay);
  };
}

// Example usage
const handleResize = debounce(() => {
  console.log('Window resized');
}, 300);

// Call handleResize() on window resize

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Example usage
const handleScroll = throttle(() => {
  console.log('Handling scroll');
}, 200);

// Call handleScroll() on window scroll

function sequentialTimeouts(callbacks, delay = 1000) {
  let index = 0;
  function next() {
    if (index < callbacks.length) {
      callbacks[index]();
      index++;
      setTimeout(next, delay);
    }
  }
  next();
}

// Example usage
sequentialTimeouts([
  () => console.log('Step 1'),
  () => console.log('Step 2'),
  () => console.log('Step 3')
], 1000);

const desiredDelay = 100; // 100ms
const start = Date.now();

setTimeout(() => {
  const actualDelay = Date.now() - start;
  console.log(`Desired delay: ${desiredDelay}ms`);
  console.log(`Actual delay: ${actualDelay}ms`);
  console.log(`Difference: ${actualDelay - desiredDelay}ms`);
}, desiredDelay);

// Leak: Interval keeps running even if not needed
function startService() {
  setInterval(() => {
    fetchData();
  }, 1000);
}

// Leak: Timeout with closure over large object
function processData(data) {
  setTimeout(() => {
    console.log('Processing complete');
   // 'data' is kept in memory until the timeout fires
  }, 10000, data);
}

// Bad practice in a server context
function startServer() {
  setInterval(() => {
    // This interval will run forever and prevent proper cleanup
    console.log('Server is running...');
  }, 60000);
}

// Better practice
function startServer() {
  const intervalId = setInterval(() => {
    console.log('Server is running...');
  }, 60000);

  // Store the interval ID for later cleanup
  return {
    stop: () => {
      clearInterval(intervalId);
      console.log('Server stopped');
    }
  };
}

// Example usage
const server = startServer();

// Stop the server after 3 minutes
setTimeout(() => {
  server.stop();
}, 180000);

function processArray(array, processFunction) {
  const chunkSize = 1000;
  let index = 0;

  function processChunk() {
    const chunk = array.slice(index, index + chunkSize);
    chunk.forEach(processFunction);

    index += chunkSize;

    if (index < array.length) {
      setTimeout(processChunk, 0); // Yield to the event loop
    } else {
      console.log('Processing complete');
    }
  }

  processChunk();
}

// Example usage
const bigArray = Array(10000).fill().map((_, i) => i);

console.log('Starting processing...');
processArray(bigArray, (item) => {
  // Simple processing
  if (item % 5000 === 0) {
    console.log(`Processed item ${item}`);
  }
});
console.log('This will log before processing completes');